<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Flow control in C#</title>
<link rel="stylesheet" href="/cfg/format.css" type="text/css">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="keywords" content="C#, learn C#, language, flow control, if, else, while, foreach, language, .NET, Mono">
<meta name="description" content="This part of the C# tutorial covers flow control.">
<meta name="language" content="en">
<meta name="author" content="Jan Bodnar">
<meta name="distribution" content="global">

<script type="text/javascript" src="/lib/jquery.js"></script>
<script type="text/javascript" src="/lib/common.js"></script>

</head>

<body>

<div class="container">

<div id="wide_ad" class="ltow">
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* 160x600, August 2011 */
google_ad_slot = "2484182563";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>


<div class="content">

<a href="/" title="Home">Home</a>&nbsp;
<a href="..">Contents</a>


<h1>Flow control in C#</h1>

<p>
In this part of the C# tutorial, we will talk about the flow control.
We will define several keywords that enable us to control the flow of 
a C# program. 
</p>

<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* NewSquare */
google_ad_slot = "0364418177";
google_ad_width = 300;
google_ad_height = 250;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script>

<p>
In C# language there are several keywords that are used
to alter the flow of the program. When the program is run, the statements 
are executed from the top of the source file to the bottom. One by one. 
This flow can be altered by specific keywords. Statements can be executed
multiple times. Some statements are called conditional statements. They
are executed only if a specific condition is met. 
</p>

<h2>The if statement</h2>

<p>
The <code>if</code> statement has the following general form:
</p>

<pre>
if (expression) 
{
    statement;
}
</pre>

<p>
The <code>if</code> keyword is used to check if an expression 
is true. If it is true, a statement is then executed. The statement can 
be a single statement or a compound statement. A compound statement 
consists of multiple statements enclosed by the block. A block is code
enclosed by curly brackets.
</p>



<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int num = 31;

        if (num > 0)
        {
            Console.WriteLine("num variable is positive");
        }
    }
}
</pre>

<p>
We have a num variable. It is assigned 31. The <code>if</code> keyword
checks for a boolean expression. The expression is put between square 
brackets. 31 > 0 is true, so the statement inside the block is executed. 
</p>

<pre>
$ ./ifstatement.exe 
num variable is positive
</pre>

<p>
The condition is met and the message is written to the console. 
</p>


<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int num = 31;

        if (num > 0)
        {
            Console.WriteLine("num variable is positive");
            Console.WriteLine("num variable equals {0}", num);
        }
    }
}
</pre>

<p>
More statements can be executed inside the block, enclosed by
curly brackets. 
</p>

<hr class="btm">

<p>
We can use the <code>else</code> keyword to create a simple branch. 
If the expression inside the square brackets following the if keyword 
evaluates to false, the statement following the <code>else</code> 
keyword is automatically executed. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        string sex = "female";

        if (sex == "male") {
          Console.WriteLine("It is a boy");
        } else {
          Console.WriteLine("It is a girl");
        }
    }
}
</pre>

<p>
We have a sex variable. It has "female" string. The boolean expression 
evaluates to false and we get "It is a girl" in the console.  
</p>

<pre>
$ ./branch.exe 
It is a girl
</pre>


<p>
We can create multiple branches using the <code>else if</code> keyword.
The <code>else if</code> keyword tests for another condition, if and only if 
the previous condition was not met. Note, that we can use multiple 
<code>else if</code> keywords in our tests.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int a = 0;

        if (a &lt; 0) {
          Console.WriteLine("a is negative");
        } else if (a == 0) { 
          Console.WriteLine("a equals to zero");
        } else {
          Console.WriteLine("a is a positive number");
        }
    }
}
</pre>

<p>
We have a numerical variable and we test it, if it is a negative number or 
positive or if it equals to zero. The first expression evaluates to false. 
The second condition is met. The program prints 'a equals to zero' to the 
console. The rest of the branch is skipped. If the previous conditions were
not met, than the statement following the <code>else</code> keyword would
be executed.
</p>

<h2>The switch statement</h2>

<p>
The <code>switch</code> statement is a selection control flow statement. 
It allows the value of a variable or expression to control the flow of program 
execution via a multi way branch. It creates multiple branches in a simpler way 
than using the combination of <code>if</code>, <code>else if</code> 
statements.
</p>

<p>
We have a variable or an expression. The <code>switch</code> keyword is used
to test a value from the variable or the expression against a list of values. 
The list of values is presented with the <code>case</code> keyword. 
If the values match, the statement following the <code>case</code> is executed. 
There is an optional <code>default</code> statement. It is executed, if no other 
match is found.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        string domain = Console.ReadLine();
    
        switch (domain) {
            case "us":
                Console.WriteLine("United States");
            break;
            case "de":
                Console.WriteLine("Germany");
            break;
            case "sk":
                Console.WriteLine("Slovakia");
            break;
            case "hu":
                Console.WriteLine("Hungary");
            break;
            default:
                Console.WriteLine("Unknown");
            break;
        }
    }
}
</pre>

<p>
In our program, we have a domain variable. We read a value for the variable
from the command line. We use the <code>case</code> statement to 
test for the value of the variable. There are several options. If the value 
equals for example to "us" the "United States" string is printed to the console. 
</p>

<pre>
$ ./selectcase.exe 
hu
Hungary
</pre>

<p>
We have entered "hu" string to the console and the program responded with "Hungary".
</p>


<h2>The while statement</h2>

<p>
The <code>while</code> statement is a control flow statement 
that allows code to be executed repeatedly based on a given boolean condition. 
</p>

<p>
This is the general form of the <code>while</code> loop:
</p>

<pre>
while (expression)
{
    statement;
}
</pre>

<p>
The <code>while</code> keyword executes the statements inside the
block enclosed by the curly brackets. The statements are executed each time 
the expression is evaluated to true. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int i = 0;
        int sum = 0;

        while (i &lt; 10)
        {
            i++;
            sum += i;   
        }
        Console.WriteLine(sum);        
    }
}
</pre>

<p>
In the code example, we calculate the sum of values from a range of numbers.
</p>

<p>
The <code>while</code> loop has three parts. Initialization, testing and 
updating. Each execution of the statement is called a cycle. 
</p>

<pre class="explanation">
int i = 0;
</pre>

<p>
We initiate the i variable. It is used as a counter.
</p>

<pre class="explanation">
while (i &lt; 10)
{
   ...
}
</pre>

<p>
The expression inside the square brackets following the <code>while</code>
keyword is the second phase, the testing. The statements in the body are 
executed, until the expression is evaluated to false. 
</p>

<pre class="explanation">
i++;
</pre>

<p>
The last, third phase of the <code>while</code> loop. The updating. We increment
the counter. Note that improper handling of the <code>while</code> loops may lead
to endless cycles. 
</p>

<hr class="btm">

<p>
It is possible to run the statement at least once. Even if the condition is not met. 
For this, we can use the <code>do while</code> keywords.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int count = 0;
        
        do { 
            Console.WriteLine(count);
        } while (count != 0);      
    }
}
</pre>

<p>
First the iteration is executed and then the truth expression is evaluated. 
</p>


<h2>The for statement</h2>

<p>
When the number of cycles is know before the loop is initiated, 
we can use the <code>for</code> statement. In this construct 
we declare a counter variable, which is automatically increased 
or decreased in value during each repetition of the loop.
</p>


<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        for (int i=0; i&lt;9; i++)
        {
            Console.WriteLine(i);
        }
    }
}
</pre>

<p>
In this example, we print numbers 0..9 to the console. 
</p>

<pre class="explanation">
for (int i=0; i&lt;9; i++)
{
    Console.WriteLine(i);
}
</pre>

<p>
There are three phases. First, we initiate the counter i to zero.
This phase is done only once. Next comes the condition. If the 
condition is met, the statement inside the for block is executed.
Then comes the third phase; the couter is increased. Now we repeat
the 2, 3 phases until the condition is not met and the for loop
is left. In our case, when the counter i is equal to 9, the for loop
stops executing.
</p>


<h2>The foreach statement</h2>

<p>
The <code>foreach</code> construct simplifies traversing over 
collections of data. It has no explicit counter. The <code>foreach</code> 
statement goes through the array or collection one by one and 
the current value is copied to a variable defined in the construct.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        string[] planets = { "Mercury", "Venus", 
            "Earth", "Mars", "Jupiter", "Saturn", 
            "Uranus", "Neptune" };

        foreach (string planet in planets)
        {
            Console.WriteLine(planet);
        }
    }
}
</pre>

<p>
In this example, we use the <code>foreach</code> statement to go
through an array of planets. 
</p>

<pre class="explanation">
foreach (string planet in planets)
{
    Console.WriteLine(planet);
}
</pre>

<p>
The usage of the <code>foreach</code> statement is straightforward.
The planets is the array, that we iterate through. The planet is the
temporary variable, that has the current value from the array. 
The <code>foreach</code> statement goes through all the planets 
and prints them to the console. 
</p>

<pre>
$ ./planets.exe 
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
</pre>

<p>
Running the above C# program gives this output.
</p>


<h2>The break, continue statements</h2>

<p>
The <code>break</code> statement can be used to terminate 
a block defined by <code>while</code>, <code>for</code>
or <code>switch</code> statements.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        Random random = new Random();

        while (true)
        {            
            int num = random.Next(1, 30);
            Console.Write(num + " ");
            
            if (num == 22)
                break;                 
        }

        Console.Write('\n');
    }
}
</pre>

<p>
We define an endless <code>while</code> loop. We use the <code>break</code> 
statement to get out of this loop. We choose a random value from 1 to 30. 
We print the value. If the value equals to 22, we finish the endless while loop. 
</p>

<pre>
$ ./break.exe 
29 21 26 6 29 3 10 3 18 6 3 22 
</pre>

<p>
We might get something like this.
</p>

<hr class="btm">

<p>
The <code>continue</code> statement is used to skip a
part of the loop and continue with the next iteration of the loop.
It can be used in combination with <code>for</code> and 
<code>while</code> statements. 
</p>

<p>
In the following example, we will print a list of numbers, 
that cannot be divided by 2 without a remainder. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main()
    {
        int num = 0;
         
        while (num &lt; 1000)
        {
            num++;

            if ((num % 2) == 0)
                continue;
            
            Console.Write(num + " "); 
        }

        Console.Write('\n');
    }
}
</pre>

<p>
We iterate through numbers 1..999 with the <code>while</code> loop.
</p>

<pre class="explanation">
if ((num % 2) == 0)
    continue;
</pre>

<p>
If the expression num % 2 returns 0, the number in question can be divided by 2.
The <code>continue</code> statement is executed and the rest of the cycle is skipped.
In our case, the last statement of the loop is skipped and the number is not printed to the
console. The next iteration is started. 
</p>

<p>
In this part of the C# tutorial, we were talking about control 
flow structures. 
</p>



<div class="botNav, center">
<span class="botNavItem"><a href="/">Home</a></span> ‡ <span class="botNavItem"><a href="..">Contents</a></span> ‡
<span class="botNavItem"><a href="#">Top of Page</a></span>
</div>


<div class="footer">
<div class="signature">
<a href="/">ZetCode</a> last modified October 16, 2010  <span class="copyright">&copy; 2007 - 2013 Jan Bodnar</span>
</div>
</div>

</div> <!-- content -->

</div> <!-- container -->

</body>
</html>
